/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package socketsjava;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
//import java.util.logging.Level;
//import java.util.logging.Logger;
//import javax.print.DocFlavor;

/**
 *
 * @author jonathan
 */
public class SocketsJava {
    
    private ObjectOutputStream salida;
    private ObjectInputStream entrada;
    private String mensaje = "";
    private String servidorChat;
    private Socket cliente;
    
    static final String host = "localhost";
    static final int puerto = 5000;
    
    public SocketsJava () throws IOException{
//        Socket skCliente = new Socket(host, puerto);
//        InputStream aux = skCliente.getInputStream();
//        DataInputStream flujo = new DataInputStream(aux);
//        System.out.println(flujo.readUTF());
//        skCliente.close();
        
        new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                //throw new UnsupportedOperationException("Not supported yet.");
                enviarDatos(e.getActionCommand());
                System.out.println("getActionCommand "+e.getActionCommand());
            }
        };
    }
    
    private void enviarDatos(String mensaje) {
        //throw new UnsupportedOperationException("Not yet implemented");
        try {
            salida.writeObject( "CLIENTE>>> " + mensaje );
            salida.flush();
            System.out.println("\nCLIENTE>>> " + mensaje );
         }

         // procesar los problemas que pueden ocurrir al enviar el objeto
         catch ( IOException excepcionES ) {
            System.out.println( "\nError al escribir el objeto" );
         }
    }
    
    private void ejecutarCliente() throws IOException {
        try {
            conectarAServidor(); // Paso 1: crear un socket para realizar la conexión
            obtenerFlujos();      // Paso 2: obtener los flujos de entrada y salida
            procesarConexion(); // Paso 3: procesar la conexión
         }

         // el servidor cerró la conexión
         catch (EOFException excepcionEOF ) {
            System.err.println( "El cliente termino la conexión" );
         }

         // procesar los problemas que pueden ocurrir al comunicarse con el servidor
         catch ( IOException excepcionES ) {
            excepcionES.printStackTrace();
         }

         finally {
            cerrarConexion(); // Paso 4: cerrar la conexión
         }
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try {
            SocketsJava cl = new SocketsJava();
            cl.ejecutarCliente();
        } catch (IOException ex) {
            //Logger.getLogger(SocketsJava.class.getName()).log(Level.SEVERE, null, ex);
            System.out.println("ERROR: "+ ex.getMessage());
        }
    }

    private void conectarAServidor() throws IOException {
        //throw new UnsupportedOperationException("Not yet implemented");
        System.out.println( "Intentando realizar conexión\n" );

      // crear Socket para realizar la conexión con el servidor
      //cliente = new Socket(InetAddress.getByName( host ), 12345 );
        cliente = new Socket(host, puerto);

      // mostrar la información de la conexión
      System.out.println( "Conectado a: " + 
         cliente.getInetAddress().getHostName() );
    }

    private void obtenerFlujos() throws IOException {
        //throw new UnsupportedOperationException("Not yet implemented");
        salida = new ObjectOutputStream( cliente.getOutputStream() );      
        salida.flush(); // vacíar búfer de salida para enviar información de encabezado

        // establecer flujo de entrada para los objetos
        entrada = new ObjectInputStream( cliente.getInputStream() );

        System.out.println( "\nSe recibieron los flujos de E/S\n" );
    }

    private void procesarConexion() throws IOException {
         
      do { // procesar mensajes enviados del servidor
 
         // leer mensaje y mostrarlo en pantalla
         try {
            mensaje = ( String ) entrada.readObject();
             System.out.println("\n" + mensaje );
         }
 
         // atrapar los problemas que pueden ocurrir al leer del servidor
         catch ( ClassNotFoundException excepcionClaseNoEncontrada ) {
            System.out.println( "\nSe recibió un objeto de tipo desconocido" );
         }
 
      } while ( !mensaje.equals( "SERVIDOR>>> TERMINAR" ) );
    }

    private void cerrarConexion() throws IOException {
        //throw new UnsupportedOperationException("Not yet implemented");
        System.out.println( "\nCerrando conexión" );
 
      try {
         salida.close();
         entrada.close();
         cliente.close();
      }
      catch( IOException excepcionES ) {
         excepcionES.printStackTrace();
      }
    }
}
